gint x,
gint y,
GtkSelectionData *selection_data,
- guint info,
guint32 time,
gpointer data)
{
gint x,
gint y,
GtkSelectionData *selection,
- guint info,
guint time,
gpointer data)
{
gint x,
gint y,
GtkSelectionData *selection,
- guint info,
guint time,
gpointer data)
{
gint x,
gint y,
GtkSelectionData *selection,
- guint info,
guint time,
gpointer data)
contents = gtk_drawing_area_new ();
g_object_connect (contents,
- "signal::draw", canvas_draw, NULL,
- "signal::drag-data-received", passive_canvas_drag_data_received, NULL,
+ "draw", canvas_draw, NULL,
+ "drag-data-received", passive_canvas_drag_data_received, NULL,
NULL);
gtk_tool_palette_add_drag_dest (GTK_TOOL_PALETTE (palette),
contents = gtk_drawing_area_new ();
g_object_connect (contents,
- "signal::draw", canvas_draw, NULL,
- "signal::drag-motion", interactive_canvas_drag_motion, NULL,
- "signal::drag-data-received", interactive_canvas_drag_data_received, NULL,
- "signal::drag-leave", interactive_canvas_drag_leave, contents,
- "signal::drag-drop", interactive_canvas_drag_drop, NULL,
+ "draw", canvas_draw, NULL,
+ "drag-motion", interactive_canvas_drag_motion, NULL,
+ "drag-data-received", interactive_canvas_drag_data_received, NULL,
+ "drag-leave", interactive_canvas_drag_leave, contents,
+ "drag-drop", interactive_canvas_drag_drop, NULL,
NULL);
gtk_tool_palette_add_drag_dest (GTK_TOOL_PALETTE (palette),
/* Drag 'n Drop */
static GtkTargetEntry target_table[] = {
- { "text/uri-list", 0, 0 },
+ { "text/uri-list", 0 },
};
typedef struct
gtk_widget_init_template (GTK_WIDGET (win));
list = gtk_target_list_new (NULL, 0);
- gtk_target_list_add_text_targets (list, 0);
+ gtk_target_list_add_text_targets (list);
gtk_icon_view_enable_model_drag_source (GTK_ICON_VIEW (win->list),
GDK_BUTTON1_MASK,
list,
static void gtk_calendar_drag_data_get (GtkWidget *widget,
GdkDragContext *context,
GtkSelectionData *selection_data,
- guint info,
guint time);
static void gtk_calendar_drag_data_received (GtkWidget *widget,
GdkDragContext *context,
gint x,
gint y,
GtkSelectionData *selection_data,
- guint info,
guint time);
static gboolean gtk_calendar_drag_motion (GtkWidget *widget,
GdkDragContext *context,
{
GdkDragContext *context;
GtkTargetList *target_list = gtk_target_list_new (NULL, 0);
- gtk_target_list_add_text_targets (target_list, 0);
+ gtk_target_list_add_text_targets (target_list);
context = gtk_drag_begin_with_coordinates (widget, target_list, GDK_ACTION_COPY,
1, (GdkEvent *)event,
priv->drag_start_x, priv->drag_start_y);
gtk_calendar_drag_data_get (GtkWidget *widget,
GdkDragContext *context,
GtkSelectionData *selection_data,
- guint info,
guint time)
{
GtkCalendar *calendar = GTK_CALENDAR (widget);
gint x,
gint y,
GtkSelectionData *selection_data,
- guint info,
guint time)
{
GtkCalendar *calendar = GTK_CALENDAR (widget);
static GtkWidget * get_clipboard_widget (GdkDisplay *display);
-enum {
- TARGET_STRING,
- TARGET_TEXT,
- TARGET_COMPOUND_TEXT,
- TARGET_UTF8_STRING,
- TARGET_SAVE_TARGETS
-};
-
static const gchar request_contents_key[] = "gtk-request-contents";
static GQuark request_contents_key_id = 0;
static void
selection_get_cb (GtkWidget *widget,
GtkSelectionData *selection_data,
- guint info,
guint time)
{
GtkClipboard *clipboard;
gtk_selection_data_get_selection (selection_data));
if (clipboard && clipboard->get_func)
- clipboard->get_func (clipboard, selection_data, info, clipboard->user_data);
+ clipboard->get_func (clipboard, selection_data, clipboard->user_data);
}
static gboolean
static void
text_get_func (GtkClipboard *clipboard,
GtkSelectionData *selection_data,
- guint info,
gpointer data)
{
gtk_selection_data_set_text (selection_data, data, -1);
g_return_if_fail (text != NULL);
targets = gtk_target_list_new (NULL, 0);
- gtk_target_list_add_text_targets (targets, 0);
+ gtk_target_list_add_text_targets (targets);
if (len < 0)
len = strlen (text);
static void
pixbuf_get_func (GtkClipboard *clipboard,
GtkSelectionData *selection_data,
- guint info,
gpointer data)
{
gtk_selection_data_set_pixbuf (selection_data, data);
g_return_if_fail (GDK_IS_PIXBUF (pixbuf));
targets = gtk_target_list_new (NULL, 0);
- gtk_target_list_add_image_targets (targets, 0, TRUE);
+ gtk_target_list_add_image_targets (targets, TRUE);
gtk_clipboard_set_with_data (clipboard,
targets,
{
gtk_selection_add_target (clipboard_widget,
clipboard->selection,
- gdk_atom_intern_static_string ("SAVE_TARGETS"),
- TARGET_SAVE_TARGETS);
+ gdk_atom_intern_static_string ("SAVE_TARGETS"));
/* Ref the owner so it won't go away */
if (clipboard->have_owner)
* @clipboard: the #GtkClipboard
* @selection_data: a #GtkSelectionData argument in which the requested
* data should be stored.
- * @info: the info field corresponding to the requested target from the
- * #GtkTargetEntry array passed to gtk_clipboard_set_with_data() or
- * gtk_clipboard_set_with_owner().
* @user_data_or_owner: the @user_data argument passed to
* gtk_clipboard_set_with_data(), or the @owner argument passed to
* gtk_clipboard_set_with_owner()
*/
typedef void (* GtkClipboardGetFunc) (GtkClipboard *clipboard,
GtkSelectionData *selection_data,
- guint info,
gpointer user_data_or_owner);
/**
static void gtk_color_button_drag_data_get (GtkWidget *widget,
GdkDragContext *context,
GtkSelectionData *selection_data,
- guint info,
guint time,
GtkColorButton *button);
gint x,
gint y,
GtkSelectionData *selection_data,
- guint info,
guint32 time,
GtkColorButton *button);
static guint color_button_signals[LAST_SIGNAL] = { 0 };
-static const GtkTargetEntry drop_types[] = { { (char *) "application/x-color", 0, 0 } };
+static const GtkTargetEntry drop_types[] = { { (char *) "application/x-color", 0 } };
static void gtk_color_button_iface_init (GtkColorChooserInterface *iface);
gint x,
gint y,
GtkSelectionData *selection_data,
- guint info,
guint32 time,
GtkColorButton *button)
{
gtk_color_button_drag_data_get (GtkWidget *widget,
GdkDragContext *context,
GtkSelectionData *selection_data,
- guint info,
guint time,
GtkColorButton *button)
{
swatch_drag_data_get (GtkWidget *widget,
GdkDragContext *context,
GtkSelectionData *selection_data,
- guint info,
guint time)
{
GtkColorSwatch *swatch = GTK_COLOR_SWATCH (widget);
gint x,
gint y,
GtkSelectionData *selection_data,
- guint info,
guint time)
{
gint length;
@implementation GtkDragSourceOwner
-(void)pasteboard:(NSPasteboard *)sender provideDataForType:(NSString *)type
{
- guint target_info;
GtkSelectionData selection_data;
selection_data.selection = NULL;
selection_data.display = gdk_display_get_default ();
if (gtk_target_list_find (info->target_list,
- selection_data.target,
- &target_info))
+ selection_data.target))
{
g_signal_emit_by_name (info->widget, "drag-data-get",
info->context,
&selection_data,
- target_info,
time);
if (selection_data.length >= 0)
gint y,
guint32 time);
-/* Enumeration for some targets we handle internally */
-
-enum {
- TARGET_DELETE = 0x40000002
-};
-
/* Forward declarations */
static void gtk_drag_get_event_actions (const GdkEvent *event,
gint button,
static void gtk_drag_selection_get (GtkWidget *widget,
GtkSelectionData *selection_data,
- guint sel_info,
guint32 time,
gpointer data);
static void gtk_drag_remove_icon (GtkDragSourceInfo *info);
if (site && site->target_list)
{
- guint target_info;
-
if (gtk_target_list_find (site->target_list,
- target,
- &target_info))
+ target))
{
if (!(site->flags & GTK_DEST_DEFAULT_DROP) ||
gtk_selection_data_get_length (selection_data) >= 0)
"drag-data-received",
context, info->drop_x, info->drop_y,
selection_data,
- target_info, time);
+ time);
}
}
else
"drag-data-received",
context, info->drop_x, info->drop_y,
selection_data,
- 0, time);
+ time);
}
if (site && site->flags & GTK_DEST_DEFAULT_DROP)
gtk_selection_add_target (info->ipc_widget,
selection,
- pair->target,
- pair->info);
+ pair->target);
tmp_list = tmp_list->next;
}
gtk_selection_add_target (info->ipc_widget,
selection,
- gdk_atom_intern_static_string ("DELETE"),
- TARGET_DELETE);
+ gdk_atom_intern_static_string ("DELETE"));
}
g_signal_emit_by_name (info->widget, "drag-data-get",
info->context, &selection_data,
- pair->info,
time);
/* FIXME: Should we check for length >= 0 here? */
static void
gtk_drag_selection_get (GtkWidget *widget,
GtkSelectionData *selection_data,
- guint sel_info,
guint32 time,
gpointer data)
{
GtkDragSourceInfo *info = data;
static GdkAtom null_atom = NULL;
- guint target_info;
if (!null_atom)
null_atom = gdk_atom_intern_static_string ("NULL");
- switch (sel_info)
+ if (gtk_selection_data_get_target (selection_data) == gdk_atom_intern_static_string ("DELETE"))
{
- case TARGET_DELETE:
g_signal_emit_by_name (info->widget,
"drag-data-delete",
info->context);
gtk_selection_data_set (selection_data, null_atom, 8, NULL, 0);
- break;
- default:
- if (gtk_target_list_find (info->target_list,
- gtk_selection_data_get_target (selection_data),
- &target_info))
- {
- g_signal_emit_by_name (info->widget, "drag-data-get",
- info->context,
- selection_data,
- target_info,
- time);
- }
- break;
+ }
+ else if (gtk_target_list_find (info->target_list,
+ gtk_selection_data_get_target (selection_data)))
+ {
+ g_signal_emit_by_name (info->widget, "drag-data-get",
+ info->context,
+ selection_data,
+ time);
}
}
gtk_target_list_ref (target_list);
else
target_list = gtk_target_list_new (NULL, 0);
- gtk_target_list_add_text_targets (target_list, 0);
+ gtk_target_list_add_text_targets (target_list);
gtk_drag_dest_set_target_list (widget, target_list);
gtk_target_list_unref (target_list);
}
gtk_target_list_ref (target_list);
else
target_list = gtk_target_list_new (NULL, 0);
- gtk_target_list_add_image_targets (target_list, 0, FALSE);
+ gtk_target_list_add_image_targets (target_list, FALSE);
gtk_drag_dest_set_target_list (widget, target_list);
gtk_target_list_unref (target_list);
}
gtk_target_list_ref (target_list);
else
target_list = gtk_target_list_new (NULL, 0);
- gtk_target_list_add_uri_targets (target_list, 0);
+ gtk_target_list_add_uri_targets (target_list);
gtk_drag_dest_set_target_list (widget, target_list);
gtk_target_list_unref (target_list);
}
gtk_target_list_ref (target_list);
else
target_list = gtk_target_list_new (NULL, 0);
- gtk_target_list_add_text_targets (target_list, 0);
+ gtk_target_list_add_text_targets (target_list);
gtk_drag_source_set_target_list (widget, target_list);
gtk_target_list_unref (target_list);
}
gtk_target_list_ref (target_list);
else
target_list = gtk_target_list_new (NULL, 0);
- gtk_target_list_add_image_targets (target_list, 0, TRUE);
+ gtk_target_list_add_image_targets (target_list, TRUE);
gtk_drag_source_set_target_list (widget, target_list);
gtk_target_list_unref (target_list);
}
gtk_target_list_ref (target_list);
else
target_list = gtk_target_list_new (NULL, 0);
- gtk_target_list_add_uri_targets (target_list, 0);
+ gtk_target_list_add_uri_targets (target_list);
gtk_drag_source_set_target_list (widget, target_list);
gtk_target_list_unref (target_list);
}
gint x,
gint y,
GtkSelectionData *selection_data,
- guint info,
guint time);
static void gtk_entry_drag_data_get (GtkWidget *widget,
GdkDragContext *context,
GtkSelectionData *selection_data,
- guint info,
guint time);
static void gtk_entry_drag_data_delete (GtkWidget *widget,
GdkDragContext *context);
guint actions = priv->editable ? GDK_ACTION_COPY | GDK_ACTION_MOVE : GDK_ACTION_COPY;
guint button;
- gtk_target_list_add_text_targets (target_list, 0);
+ gtk_target_list_add_text_targets (target_list);
gtk_entry_get_pixel_ranges (entry, &ranges, &n_ranges);
static void
primary_get_cb (GtkClipboard *clipboard,
GtkSelectionData *selection_data,
- guint info,
gpointer data)
{
GtkEntry *entry = GTK_ENTRY (data);
return;
list = gtk_target_list_new (NULL, 0);
- gtk_target_list_add_text_targets (list, 0);
+ gtk_target_list_add_text_targets (list);
clipboard = gtk_widget_get_clipboard (GTK_WIDGET (entry), GDK_SELECTION_PRIMARY);
gint x,
gint y,
GtkSelectionData *selection_data,
- guint info,
guint time)
{
GtkEntry *entry = GTK_ENTRY (widget);
gtk_entry_drag_data_get (GtkWidget *widget,
GdkDragContext *context,
GtkSelectionData *selection_data,
- guint info,
guint time)
{
GtkEntry *entry = GTK_ENTRY (widget);
};
-/* ************* *
- * DnD Support *
- * ************* */
-
-enum
-{
- TEXT_PLAIN,
- TEXT_URI_LIST
-};
-
-
/* ********************* *
* Function Prototypes *
* ********************* */
gint x,
gint y,
GtkSelectionData *data,
- guint type,
guint drag_time);
static void gtk_file_chooser_button_show (GtkWidget *widget);
static void gtk_file_chooser_button_hide (GtkWidget *widget);
/* DnD */
target_list = gtk_target_list_new (NULL, 0);
- gtk_target_list_add_uri_targets (target_list, TEXT_URI_LIST);
- gtk_target_list_add_text_targets (target_list, TEXT_PLAIN);
+ gtk_target_list_add_uri_targets (target_list);
+ gtk_target_list_add_text_targets (target_list);
gtk_drag_dest_set (GTK_WIDGET (button),
(GTK_DEST_DEFAULT_ALL),
target_list,
gint x,
gint y,
GtkSelectionData *data,
- guint type,
guint drag_time)
{
GtkFileChooserButton *button = GTK_FILE_CHOOSER_BUTTON (widget);
GTK_WIDGET_CLASS (gtk_file_chooser_button_parent_class)->drag_data_received (widget,
context,
x, y,
- data, type,
+ data,
drag_time);
if (widget == NULL || context == NULL || data == NULL || gtk_selection_data_get_length (data) < 0)
return;
- switch (type)
+ if (gtk_selection_data_targets_include_uri (data))
{
- case TEXT_URI_LIST:
- {
- gchar **uris;
- struct DndSelectFolderData *info;
-
- uris = gtk_selection_data_get_uris (data);
-
- if (uris == NULL)
- break;
-
- info = g_new0 (struct DndSelectFolderData, 1);
- info->button = g_object_ref (button);
- info->i = 0;
- info->uris = uris;
- info->selected = FALSE;
- info->file_system = priv->fs;
- g_object_get (priv->chooser, "action", &info->action, NULL);
+ gchar **uris;
+ struct DndSelectFolderData *info;
- info->file = g_file_new_for_uri (info->uris[info->i]);
+ uris = gtk_selection_data_get_uris (data);
- if (priv->dnd_select_folder_cancellable)
- g_cancellable_cancel (priv->dnd_select_folder_cancellable);
-
- priv->dnd_select_folder_cancellable =
- _gtk_file_system_get_info (priv->fs, info->file,
- "standard::type",
- dnd_select_folder_get_info_cb, info);
- }
- break;
-
- case TEXT_PLAIN:
+ if (uris != NULL)
+ {
+ info = g_new0 (struct DndSelectFolderData, 1);
+ info->button = g_object_ref (button);
+ info->i = 0;
+ info->uris = uris;
+ info->selected = FALSE;
+ info->file_system = priv->fs;
+ g_object_get (priv->chooser, "action", &info->action, NULL);
+
+ info->file = g_file_new_for_uri (info->uris[info->i]);
+
+ if (priv->dnd_select_folder_cancellable)
+ g_cancellable_cancel (priv->dnd_select_folder_cancellable);
+
+ priv->dnd_select_folder_cancellable =
+ _gtk_file_system_get_info (priv->fs, info->file,
+ "standard::type",
+ dnd_select_folder_get_info_cb, info);
+ }
+ }
+ else if (gtk_selection_data_targets_include_text (data))
+ {
text = (char*) gtk_selection_data_get_text (data);
file = g_file_new_for_uri (text);
gtk_file_chooser_select_file (GTK_FILE_CHOOSER (priv->chooser), file, NULL);
g_object_unref (file);
g_free (text);
g_signal_emit (button, file_chooser_button_signals[FILE_SET], 0);
- break;
-
- default:
- break;
}
gtk_drag_finish (context, TRUE, FALSE, drag_time);
* GtkFileChooserWidget has a single CSS node with name filechooser.
*/
-
-/* Values for GtkSelection-related "info" fields */
-#define SELECTION_TEXT 0
-#define SELECTION_URI 1
-
/* 150 mseconds of delay */
#define LOCATION_CHANGED_TIMEOUT 150
static void
copy_file_get_cb (GtkClipboard *clipboard,
GtkSelectionData *selection_data,
- guint info,
gpointer data)
{
GSList *selected_files = data;
{
GFile *file = (GFile *) l->data;
- if (info == SELECTION_URI)
+ if (gtk_selection_data_targets_include_uri (selection_data))
uris[i] = g_file_get_uri (file);
else /* if (info == SELECTION_TEXT) - let this be the fallback */
uris[i] = g_file_get_parse_name (file);
i++;
}
- if (info == SELECTION_URI)
+ if (gtk_selection_data_targets_include_uri (selection_data))
gtk_selection_data_set_uris (selection_data, uris);
else /* if (info == SELECTION_TEXT) - let this be the fallback */
{
clipboard = gtk_widget_get_clipboard (GTK_WIDGET (impl), GDK_SELECTION_CLIPBOARD);
target_list = gtk_target_list_new (NULL, 0);
- gtk_target_list_add_text_targets (target_list, SELECTION_TEXT);
- gtk_target_list_add_uri_targets (target_list, SELECTION_URI);
+ gtk_target_list_add_text_targets (target_list);
+ gtk_target_list_add_uri_targets (target_list);
gtk_clipboard_set_with_data (clipboard, target_list,
copy_file_get_cb,
gint x,
gint y,
GtkSelectionData *selection_data,
- guint info,
guint time_,
gpointer user_data)
{
static void gtk_icon_view_drag_data_get (GtkWidget *widget,
GdkDragContext *context,
GtkSelectionData *selection_data,
- guint info,
guint time);
static void gtk_icon_view_drag_data_delete (GtkWidget *widget,
GdkDragContext *context);
gint x,
gint y,
GtkSelectionData *selection_data,
- guint info,
guint time);
static gboolean gtk_icon_view_maybe_begin_drag (GtkIconView *icon_view,
GdkEventMotion *event);
gtk_icon_view_drag_data_get (GtkWidget *widget,
GdkDragContext *context,
GtkSelectionData *selection_data,
- guint info,
guint time)
{
GtkIconView *icon_view;
gint x,
gint y,
GtkSelectionData *selection_data,
- guint info,
guint time)
{
GtkTreePath *path;
}
static const GtkTargetEntry item_targets[] = {
- { (char *) "GTK_TREE_MODEL_ROW", GTK_TARGET_SAME_WIDGET, 0 }
+ { (char *) "GTK_TREE_MODEL_ROW", GTK_TARGET_SAME_WIDGET }
};
static void gtk_label_drag_data_get (GtkWidget *widget,
GdkDragContext *context,
GtkSelectionData *selection_data,
- guint info,
guint time);
static void gtk_label_buildable_interface_init (GtkBuildableIface *iface);
const GdkEvent *event;
event = gtk_gesture_get_last_event (GTK_GESTURE (gesture), sequence);
- gtk_target_list_add_text_targets (target_list, 0);
+ gtk_target_list_add_text_targets (target_list);
g_signal_connect (widget, "drag-begin",
G_CALLBACK (drag_begin_cb), NULL);
gtk_label_drag_data_get (GtkWidget *widget,
GdkDragContext *context,
GtkSelectionData *selection_data,
- guint info,
guint time)
{
gtk_label_set_selection_text (GTK_LABEL (widget), selection_data);
static void
get_text_callback (GtkClipboard *clipboard,
GtkSelectionData *selection_data,
- guint info,
gpointer user_data_or_owner)
{
gtk_label_set_selection_text (GTK_LABEL (user_data_or_owner), selection_data);
GtkTargetList *list;
list = gtk_target_list_new (NULL, 0);
- gtk_target_list_add_text_targets (list, 0);
+ gtk_target_list_add_text_targets (list);
if (clipboard)
gtk_clipboard_set_with_owner (clipboard,
static void gtk_link_button_drag_data_get_cb (GtkWidget *widget,
GdkDragContext *context,
GtkSelectionData *selection,
- guint _info,
guint _time,
gpointer user_data);
static gboolean gtk_link_button_query_tooltip_cb (GtkWidget *widget,
gboolean show_hand);
static const GtkTargetEntry link_drop_types[] = {
- { (char *) "text/uri-list", 0, 0 },
- { (char *) "_NETSCAPE_URL", 0, 0 }
+ { (char *) "text/uri-list", 0 },
+ { (char *) "_NETSCAPE_URL", 0 }
};
static guint link_signals[LAST_SIGNAL] = { 0, };
gtk_link_button_drag_data_get_cb (GtkWidget *widget,
GdkDragContext *context,
GtkSelectionData *selection,
- guint _info,
guint _time,
gpointer user_data)
{
VOID:BOXED,STRING,INT
VOID:BOXED,UINT
VOID:BOXED,UINT,FLAGS
-VOID:BOXED,UINT,UINT
VOID:ENUM,BOOLEAN
VOID:ENUM,ENUM
VOID:ENUM,FLOAT
VOID:INT,INT,INT
VOID:OBJECT,BOOLEAN
VOID:OBJECT,BOXED,BOXED
-VOID:OBJECT,BOXED,UINT,UINT
+VOID:OBJECT,BOXED,UINT
VOID:OBJECT,BOXED,BOOLEAN,BOOLEAN
VOID:OBJECT,ENUM
VOID:OBJECT,FLAGS
VOID:OBJECT,INT
VOID:OBJECT,INT,OBJECT
VOID:OBJECT,INT,INT
-VOID:OBJECT,INT,INT,BOXED,UINT,UINT
+VOID:OBJECT,INT,INT,BOXED,UINT
VOID:OBJECT,OBJECT
VOID:OBJECT,POINTER
VOID:OBJECT,POINTER,INT
};
static const GtkTargetEntry src_notebook_targets [] = {
- { (char *) "GTK_NOTEBOOK_TAB", GTK_TARGET_SAME_APP, 0 },
- { (char *) "application/x-rootwindow-drop", 0, 0 },
+ { (char *) "GTK_NOTEBOOK_TAB", GTK_TARGET_SAME_APP },
+ { (char *) "application/x-rootwindow-drop", 0 },
};
static const GtkTargetEntry dst_notebook_targets [] = {
- { (char *) "GTK_NOTEBOOK_TAB", GTK_TARGET_SAME_APP, 0 },
+ { (char *) "GTK_NOTEBOOK_TAB", GTK_TARGET_SAME_APP },
};
/*** GtkNotebook Methods ***/
static void gtk_notebook_drag_data_get (GtkWidget *widget,
GdkDragContext *context,
GtkSelectionData *data,
- guint info,
guint time);
static void gtk_notebook_drag_data_received (GtkWidget *widget,
GdkDragContext *context,
gint x,
gint y,
GtkSelectionData *data,
- guint info,
guint time);
static void gtk_notebook_direction_changed (GtkWidget *widget,
GtkTextDirection previous_direction);
gtk_notebook_drag_data_get (GtkWidget *widget,
GdkDragContext *context,
GtkSelectionData *data,
- guint info,
guint time)
{
GtkNotebook *notebook = GTK_NOTEBOOK (widget);
gint x,
gint y,
GtkSelectionData *data,
- guint info,
guint time)
{
GtkNotebook *notebook;
* gint x,
* gint y,
* GtkSelectionData *data,
- * guint info,
* guint time,
* gpointer user_data)
* {
button_drag_data_get_cb (GtkWidget *widget,
GdkDragContext *context,
GtkSelectionData *selection_data,
- guint info,
guint time_,
gpointer data)
{
/* Target types for dragging from the shortcuts list */
static const GtkTargetEntry dnd_source_targets[] = {
- { (char *) "DND_GTK_SIDEBAR_ROW", GTK_TARGET_SAME_WIDGET, DND_GTK_SIDEBAR_ROW }
+ { (char *) "DND_GTK_SIDEBAR_ROW", GTK_TARGET_SAME_WIDGET }
};
/* Target types for dropping into the shortcuts list */
static const GtkTargetEntry dnd_drop_targets [] = {
- { (char *) "DND_GTK_SIDEBAR_ROW", GTK_TARGET_SAME_WIDGET, DND_GTK_SIDEBAR_ROW }
+ { (char *) "DND_GTK_SIDEBAR_ROW", GTK_TARGET_SAME_WIDGET }
};
G_DEFINE_TYPE (GtkPlacesSidebar, gtk_places_sidebar, GTK_TYPE_SCROLLED_WINDOW);
drag_data_get_callback (GtkWidget *widget,
GdkDragContext *context,
GtkSelectionData *data,
- guint info,
- guint time,
gpointer user_data)
{
GtkPlacesSidebar *sidebar = GTK_PLACES_SIDEBAR (user_data);
int x,
int y,
GtkSelectionData *selection_data,
- guint info,
guint time,
gpointer user_data)
{
if (!sidebar->drag_data_received)
{
- if (gtk_selection_data_get_target (selection_data) != NULL &&
- info == DND_TEXT_URI_LIST)
+ if (gtk_selection_data_targets_include_uri (selection_data))
{
gchar **uris;
g_list_free_full (sidebar->drag_list, g_object_unref);
sidebar->drag_list = build_file_list_from_uris ((const char **) uris);
g_strfreev (uris);
+ sidebar->drag_data_info = DND_TEXT_URI_LIST;
}
else
{
sidebar->drag_list = NULL;
+ if (gtk_selection_data_get_target (selection_data) == gdk_atom_intern_static_string ("DND_GTK_SIDEBAR_ROW"))
+ sidebar->drag_data_info = DND_GTK_SIDEBAR_ROW;
}
sidebar->drag_data_received = TRUE;
- sidebar->drag_data_info = info;
}
g_signal_stop_emission_by_name (list_box, "drag-data-received");
NULL,
GDK_ACTION_MOVE | GDK_ACTION_COPY | GDK_ACTION_LINK);
target_list = gtk_target_list_new (dnd_drop_targets, G_N_ELEMENTS (dnd_drop_targets));
- gtk_target_list_add_uri_targets (target_list, DND_TEXT_URI_LIST);
+ gtk_target_list_add_uri_targets (target_list);
gtk_drag_dest_set_target_list (sidebar->list_box, target_list);
gtk_target_list_unref (target_list);
sidebar->source_targets = gtk_target_list_new (dnd_source_targets, G_N_ELEMENTS (dnd_source_targets));
- gtk_target_list_add_text_targets (sidebar->source_targets, 0);
+ gtk_target_list_add_text_targets (sidebar->source_targets);
g_signal_connect (sidebar->list_box, "motion-notify-event",
G_CALLBACK (on_motion_notify_event), sidebar);
* @list: a #GtkTargetList
* @target: the interned atom representing the target
* @flags: the flags for this target
- * @info: an ID that will be passed back to the application
*
* Appends another target to a #GtkTargetList.
**/
void
gtk_target_list_add (GtkTargetList *list,
GdkAtom target,
- guint flags,
- guint info)
+ guint flags)
{
GtkTargetPair *pair;
pair = g_slice_new (GtkTargetPair);
pair->target = target;
pair->flags = flags;
- pair->info = info;
list->list = g_list_append (list->list, pair);
}
/**
* gtk_target_list_add_text_targets:
* @list: a #GtkTargetList
- * @info: an ID that will be passed back to the application
*
* Appends the text targets supported by #GtkSelectionData to
* the target list. All targets are added with the same @info.
* Since: 2.6
**/
void
-gtk_target_list_add_text_targets (GtkTargetList *list,
- guint info)
+gtk_target_list_add_text_targets (GtkTargetList *list)
{
g_return_if_fail (list != NULL);
/* Keep in sync with gtk_selection_data_targets_include_text()
*/
- gtk_target_list_add (list, utf8_atom, 0, info);
- gtk_target_list_add (list, ctext_atom, 0, info);
- gtk_target_list_add (list, text_atom, 0, info);
- gtk_target_list_add (list, GDK_TARGET_STRING, 0, info);
- gtk_target_list_add (list, text_plain_utf8_atom, 0, info);
+ gtk_target_list_add (list, utf8_atom, 0);
+ gtk_target_list_add (list, ctext_atom, 0);
+ gtk_target_list_add (list, text_atom, 0);
+ gtk_target_list_add (list, GDK_TARGET_STRING, 0);
+ gtk_target_list_add (list, text_plain_utf8_atom, 0);
if (!g_get_charset (NULL))
- gtk_target_list_add (list, text_plain_locale_atom, 0, info);
- gtk_target_list_add (list, text_plain_atom, 0, info);
+ gtk_target_list_add (list, text_plain_locale_atom, 0);
+ gtk_target_list_add (list, text_plain_atom, 0);
}
/**
* gtk_target_list_add_rich_text_targets:
* @list: a #GtkTargetList
- * @info: an ID that will be passed back to the application
* @deserializable: if %TRUE, then deserializable rich text formats
* will be added, serializable formats otherwise.
* @buffer: a #GtkTextBuffer.
**/
void
gtk_target_list_add_rich_text_targets (GtkTargetList *list,
- guint info,
gboolean deserializable,
GtkTextBuffer *buffer)
{
atoms = gtk_text_buffer_get_serialize_formats (buffer, &n_atoms);
for (i = 0; i < n_atoms; i++)
- gtk_target_list_add (list, atoms[i], 0, info);
+ gtk_target_list_add (list, atoms[i], 0);
g_free (atoms);
}
/**
* gtk_target_list_add_image_targets:
* @list: a #GtkTargetList
- * @info: an ID that will be passed back to the application
* @writable: whether to add only targets for which GTK+ knows
* how to convert a pixbuf into the format
*
**/
void
gtk_target_list_add_image_targets (GtkTargetList *list,
- guint info,
gboolean writable)
{
GSList *formats, *f;
for (m = mimes; *m; m++)
{
atom = gdk_atom_intern (*m, FALSE);
- gtk_target_list_add (list, atom, 0, info);
+ gtk_target_list_add (list, atom, 0);
}
g_strfreev (mimes);
}
* Since: 2.6
**/
void
-gtk_target_list_add_uri_targets (GtkTargetList *list,
- guint info)
+gtk_target_list_add_uri_targets (GtkTargetList *list)
{
g_return_if_fail (list != NULL);
init_atoms ();
- gtk_target_list_add (list, text_uri_list_atom, 0, info);
+ gtk_target_list_add (list, text_uri_list_atom, 0);
}
/**
GtkTargetPair *pair = g_slice_new (GtkTargetPair);
pair->target = gdk_atom_intern (targets[i].target, FALSE);
pair->flags = targets[i].flags;
- pair->info = targets[i].info;
list->list = g_list_prepend (list->list, pair);
}
* gtk_target_list_find:
* @list: a #GtkTargetList
* @target: an interned atom representing the target to search for
- * @info: (out) (allow-none): a pointer to the location to store
- * application info for target, or %NULL
*
* Looks up a given target in a #GtkTargetList.
*
**/
gboolean
gtk_target_list_find (GtkTargetList *list,
- GdkAtom target,
- guint *info)
+ GdkAtom target)
{
GList *tmp_list;
GtkTargetPair *pair = tmp_list->data;
if (pair->target == target)
- {
- if (info)
- *info = pair->info;
-
- return TRUE;
- }
+ return TRUE;
tmp_list = tmp_list->next;
}
* @widget: a #GtkWidget
* @selection: the selection
* @target: target to add.
- * @info: A unsigned integer which will be passed back to the application.
*
* Appends a specified target to the list of supported targets for a
* given widget and selection.
void
gtk_selection_add_target (GtkWidget *widget,
GdkAtom selection,
- GdkAtom target,
- guint info)
+ GdkAtom target)
{
GtkTargetList *list;
g_return_if_fail (selection != NULL);
list = gtk_selection_target_list_get (widget, selection);
- gtk_target_list_add (list, target, 0, info);
+ gtk_target_list_add (list, target, 0);
gdk_selection_add_targets (gtk_widget_get_window (widget), selection, &target, 1);
}
g_return_val_if_fail (targets != NULL || n_targets == 0, FALSE);
list = gtk_target_list_new (NULL, 0);
- gtk_target_list_add_image_targets (list, 0, writable);
+ gtk_target_list_add_image_targets (list, writable);
for (i = 0; i < n_targets && !result; i++)
{
for (l = list->list; l; l = l->next)
guint time)
{
GtkTargetList *target_list;
- guint info;
-
g_return_if_fail (widget != NULL);
target_list = gtk_selection_target_list_get (widget, data->selection);
if (data->target != gtk_selection_atoms[SAVE_TARGETS] &&
target_list &&
- gtk_target_list_find (target_list, data->target, &info))
+ gtk_target_list_find (target_list, data->target))
{
g_signal_emit_by_name (widget,
"selection-get",
data,
- info, time);
+ time);
}
else
gtk_selection_default_handler (widget, data);
{
GdkAtom target;
guint flags;
- guint info;
};
/**
{
gchar *target;
guint flags;
- guint info;
};
GDK_AVAILABLE_IN_ALL
GDK_AVAILABLE_IN_ALL
void gtk_target_list_add (GtkTargetList *list,
GdkAtom target,
- guint flags,
- guint info);
+ guint flags);
GDK_AVAILABLE_IN_ALL
-void gtk_target_list_add_text_targets (GtkTargetList *list,
- guint info);
+void gtk_target_list_add_text_targets (GtkTargetList *list);
GDK_AVAILABLE_IN_ALL
void gtk_target_list_add_rich_text_targets (GtkTargetList *list,
- guint info,
gboolean deserializable,
GtkTextBuffer *buffer);
GDK_AVAILABLE_IN_ALL
void gtk_target_list_add_image_targets (GtkTargetList *list,
- guint info,
gboolean writable);
GDK_AVAILABLE_IN_ALL
-void gtk_target_list_add_uri_targets (GtkTargetList *list,
- guint info);
+void gtk_target_list_add_uri_targets (GtkTargetList *list);
GDK_AVAILABLE_IN_ALL
void gtk_target_list_add_table (GtkTargetList *list,
const GtkTargetEntry *targets,
GdkAtom target);
GDK_AVAILABLE_IN_ALL
gboolean gtk_target_list_find (GtkTargetList *list,
- GdkAtom target,
- guint *info);
+ GdkAtom target);
GDK_AVAILABLE_IN_ALL
gboolean gtk_selection_owner_set (GtkWidget *widget,
GDK_AVAILABLE_IN_ALL
void gtk_selection_add_target (GtkWidget *widget,
GdkAtom selection,
- GdkAtom target,
- guint info);
+ GdkAtom target);
GDK_AVAILABLE_IN_ALL
void gtk_selection_add_targets (GtkWidget *widget,
GdkAtom selection,
static void
clipboard_get_selection_cb (GtkClipboard *clipboard,
GtkSelectionData *selection_data,
- guint info,
gpointer data)
{
GtkTextBuffer *buffer = GTK_TEXT_BUFFER (data);
if (gtk_text_buffer_get_selection_bounds (buffer, &start, &end))
{
- if (info == GTK_TEXT_BUFFER_TARGET_INFO_BUFFER_CONTENTS)
+ if (gtk_selection_data_get_target (selection_data) == gdk_atom_intern_static_string ("GTK_TEXT_BUFFER_CONTENTS"))
{
/* Provide the address of the buffer; this will only be
* used within-process
(void*)&buffer,
sizeof (buffer));
}
- else if (info == GTK_TEXT_BUFFER_TARGET_INFO_RICH_TEXT)
+ else if (gtk_selection_data_targets_include_rich_text (selection_data, buffer))
{
guint8 *str;
gsize len;
str, len);
g_free (str);
}
- else
+ else if (gtk_selection_data_targets_include_text (selection_data))
{
gchar *str;
static void
clipboard_get_contents_cb (GtkClipboard *clipboard,
GtkSelectionData *selection_data,
- guint info,
gpointer data)
{
GtkTextBuffer *contents = GTK_TEXT_BUFFER (data);
g_assert (contents); /* This should never be called unless we own the clipboard */
- if (info == GTK_TEXT_BUFFER_TARGET_INFO_BUFFER_CONTENTS)
+ if (gtk_selection_data_get_target (selection_data) == gdk_atom_intern_static_string ("GTK_TEXT_BUFFER_CONTENTS"))
{
/* Provide the address of the clipboard buffer; this will only
* be used within-process. OK to supply a NULL value for contents.
(void*)&contents,
sizeof (contents));
}
- else if (info == GTK_TEXT_BUFFER_TARGET_INFO_RICH_TEXT)
+ else if (gtk_selection_data_targets_include_rich_text (selection_data, contents))
{
GtkTextBuffer *clipboard_source_buffer;
GtkTextIter start, end;
if (include_local)
gtk_target_list_add (target_list,
gdk_atom_intern_static_string ("GTK_TEXT_BUFFER_CONTENTS"),
- GTK_TARGET_SAME_APP,
- GTK_TEXT_BUFFER_TARGET_INFO_BUFFER_CONTENTS);
+ GTK_TARGET_SAME_APP);
gtk_target_list_add_rich_text_targets (target_list,
- GTK_TEXT_BUFFER_TARGET_INFO_RICH_TEXT,
deserializable,
buffer);
- gtk_target_list_add_text_targets (target_list,
- GTK_TEXT_BUFFER_TARGET_INFO_TEXT);
+ gtk_target_list_add_text_targets (target_list);
return target_list;
}
static void gtk_text_view_drag_data_get (GtkWidget *widget,
GdkDragContext *context,
GtkSelectionData *selection_data,
- guint info,
guint time);
static void gtk_text_view_drag_data_delete (GtkWidget *widget,
GdkDragContext *context);
gint x,
gint y,
GtkSelectionData *selection_data,
- guint info,
guint time);
static gboolean gtk_text_view_popup_menu (GtkWidget *widget);
gtk_text_view_drag_data_get (GtkWidget *widget,
GdkDragContext *context,
GtkSelectionData *selection_data,
- guint info,
guint time)
{
GtkTextView *text_view = GTK_TEXT_VIEW (widget);
GtkTextBuffer *buffer = gtk_text_view_get_buffer (text_view);
- if (info == GTK_TEXT_BUFFER_TARGET_INFO_BUFFER_CONTENTS)
+ if (gtk_selection_data_get_target (selection_data) == gdk_atom_intern_static_string ("GTK_TEXT_BUFFER_CONTENTS"))
{
gtk_selection_data_set (selection_data,
gdk_atom_intern_static_string ("GTK_TEXT_BUFFER_CONTENTS"),
(void*)&buffer,
sizeof (buffer));
}
- else if (info == GTK_TEXT_BUFFER_TARGET_INFO_RICH_TEXT)
+ else if (gtk_selection_data_targets_include_rich_text (selection_data, buffer))
{
GtkTextIter start;
GtkTextIter end;
gint x,
gint y,
GtkSelectionData *selection_data,
- guint info,
guint time)
{
GtkTextIter drop_point;
gtk_text_buffer_begin_user_action (buffer);
- if (info == GTK_TEXT_BUFFER_TARGET_INFO_BUFFER_CONTENTS)
+ if (gtk_selection_data_get_target (selection_data) == gdk_atom_intern_static_string ("GTK_TEXT_BUFFER_CONTENTS"))
{
GtkTextBuffer *src_buffer = NULL;
GtkTextIter start, end;
}
}
else if (gtk_selection_data_get_length (selection_data) > 0 &&
- info == GTK_TEXT_BUFFER_TARGET_INFO_RICH_TEXT)
+ gtk_selection_data_targets_include_rich_text (selection_data, buffer))
{
gboolean retval;
GError *error = NULL;
static const GtkTargetEntry dnd_targets[] =
{
- { (char *) "application/x-gtk-tool-palette-item", GTK_TARGET_SAME_APP, 0 },
- { (char *) "application/x-gtk-tool-palette-group", GTK_TARGET_SAME_APP, 0 },
+ { (char *) "application/x-gtk-tool-palette-item", GTK_TARGET_SAME_APP },
+ { (char *) "application/x-gtk-tool-palette-group", GTK_TARGET_SAME_APP },
};
static void gtk_tool_palette_set_hadjustment (GtkToolPalette *palette,
gtk_tool_palette_item_drag_data_get (GtkWidget *widget,
GdkDragContext *context,
GtkSelectionData *selection,
- guint info,
guint time,
gpointer data)
{
static void gtk_tree_view_drag_data_get (GtkWidget *widget,
GdkDragContext *context,
GtkSelectionData *selection_data,
- guint info,
guint time);
static void gtk_tree_view_drag_data_delete (GtkWidget *widget,
GdkDragContext *context);
gint x,
gint y,
GtkSelectionData *selection_data,
- guint info,
guint time);
/* tree_model signals */
gtk_tree_view_drag_data_get (GtkWidget *widget,
GdkDragContext *context,
GtkSelectionData *selection_data,
- guint info,
guint time)
{
GtkTreeView *tree_view;
gint x,
gint y,
GtkSelectionData *selection_data,
- guint info,
guint time)
{
GtkTreePath *path;
if (reorderable)
{
const GtkTargetEntry row_targets[] = {
- { (char *) "GTK_TREE_MODEL_ROW", GTK_TARGET_SAME_WIDGET, 0 }
+ { (char *) "GTK_TREE_MODEL_ROW", GTK_TARGET_SAME_WIDGET }
};
GtkTargetList *targets;
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, selection_get),
NULL, NULL,
- _gtk_marshal_VOID__BOXED_UINT_UINT,
- G_TYPE_NONE, 3,
+ _gtk_marshal_VOID__BOXED_UINT,
+ G_TYPE_NONE, 2,
GTK_TYPE_SELECTION_DATA | G_SIGNAL_TYPE_STATIC_SCOPE,
- G_TYPE_UINT,
G_TYPE_UINT);
/**
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, drag_data_get),
NULL, NULL,
- _gtk_marshal_VOID__OBJECT_BOXED_UINT_UINT,
- G_TYPE_NONE, 4,
+ _gtk_marshal_VOID__OBJECT_BOXED_UINT,
+ G_TYPE_NONE, 3,
GDK_TYPE_DRAG_CONTEXT,
GTK_TYPE_SELECTION_DATA | G_SIGNAL_TYPE_STATIC_SCOPE,
- G_TYPE_UINT,
G_TYPE_UINT);
/**
* @x: where the drop happened
* @y: where the drop happened
* @data: the received data
- * @info: the info that has been registered with the target in the
- * #GtkTargetList
* @time: the timestamp at which the data was received
*
* The ::drag-data-received signal is emitted on the drop site when the
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, drag_data_received),
NULL, NULL,
- _gtk_marshal_VOID__OBJECT_INT_INT_BOXED_UINT_UINT,
- G_TYPE_NONE, 6,
+ _gtk_marshal_VOID__OBJECT_INT_INT_BOXED_UINT,
+ G_TYPE_NONE, 5,
GDK_TYPE_DRAG_CONTEXT,
G_TYPE_INT,
G_TYPE_INT,
GTK_TYPE_SELECTION_DATA | G_SIGNAL_TYPE_STATIC_SCOPE,
- G_TYPE_UINT,
G_TYPE_UINT);
/**
/* selection */
void (* selection_get) (GtkWidget *widget,
GtkSelectionData *selection_data,
- guint info,
guint time_);
void (* selection_received) (GtkWidget *widget,
GtkSelectionData *selection_data,
void (* drag_data_get) (GtkWidget *widget,
GdkDragContext *context,
GtkSelectionData *selection_data,
- guint info,
guint time_);
void (* drag_data_delete) (GtkWidget *widget,
GdkDragContext *context);
gint x,
gint y,
GtkSelectionData *selection_data,
- guint info,
guint time_);
gboolean (* drag_failed) (GtkWidget *widget,
GdkDragContext *context,
};
static const GtkTargetEntry dnd_dest_targets [] = {
- { (char *) "application/x-rootwindow-drop", 0, 0 },
+ { (char *) "application/x-rootwindow-drop", 0 },
};
enum {
gboolean have_drag;
-enum {
- TARGET_STRING,
- TARGET_ROOTWIN
-};
-
static GtkTargetEntry target_table[] = {
- { "STRING", 0, TARGET_STRING },
- { "text/plain", 0, TARGET_STRING },
- { "application/x-rootwindow-drop", 0, TARGET_ROOTWIN }
+ { "STRING", 0 },
+ { "text/plain", 0 },
+ { "application/x-rootwindow-drop", 0 }
};
static guint n_targets = sizeof(target_table) / sizeof(target_table[0]);
source_drag_data_get (GtkWidget *widget,
GdkDragContext *context,
GtkSelectionData *selection_data,
- guint info,
guint time,
gpointer data)
{
- if (info == TARGET_ROOTWIN)
+ if (gtk_selection_data_get_target (selection_data) == gdk_atom_intern_static_string ("application/x-rootwindow-drop"))
g_print ("I was dropped on the rootwin\n");
else
gtk_selection_data_set (selection_data,
}
}
-enum {
- TARGET_IMAGE,
- TARGET_TEXT
-};
-
enum {
TOP_LEFT,
CENTER,
target_list = gtk_target_list_new (NULL, 0);
- gtk_target_list_add_image_targets (target_list, TARGET_IMAGE, FALSE);
+ gtk_target_list_add_image_targets (target_list, FALSE);
if (gtk_image_get_storage_type (GTK_IMAGE (image)) == GTK_IMAGE_ICON_NAME)
- gtk_target_list_add_text_targets (target_list, TARGET_TEXT);
+ gtk_target_list_add_text_targets (target_list);
gtk_drag_source_set_target_list (image, target_list);
target_list = gtk_target_list_new (NULL, 0);
- gtk_target_list_add_image_targets (target_list, TARGET_IMAGE, FALSE);
- gtk_target_list_add_text_targets (target_list, TARGET_TEXT);
+ gtk_target_list_add_image_targets (target_list, FALSE);
+ gtk_target_list_add_text_targets (target_list);
gtk_drag_dest_set_target_list (image, target_list);
image_drag_data_get (GtkWidget *widget,
GdkDragContext *context,
GtkSelectionData *selection_data,
- guint info,
guint time,
gpointer data)
{
const gchar *name;
int size;
- switch (info)
+ if (gtk_selection_data_targets_include_image (selection_data, TRUE))
{
- case TARGET_IMAGE:
surface = get_image_surface (GTK_IMAGE (data), &size);
gtk_selection_data_set_surface (selection_data, surface);
- break;
- case TARGET_TEXT:
+ }
+ else if (gtk_selection_data_targets_include_text (selection_data))
+ {
if (gtk_image_get_storage_type (GTK_IMAGE (data)) == GTK_IMAGE_ICON_NAME)
name = gtk_image_get_icon_name (GTK_IMAGE (data));
else
name = "Boo!";
gtk_selection_data_set_text (selection_data, name, -1);
- break;
- default:
+ }
+ else
+ {
g_assert_not_reached ();
}
}
gint x,
gint y,
GtkSelectionData *selection_data,
- guint info,
guint32 time,
gpointer data)
{
if (gtk_selection_data_get_length (selection_data) == 0)
return;
- switch (info)
+ if (gtk_selection_data_targets_include_image (selection_data, FALSE))
{
- case TARGET_IMAGE:
surface = gtk_selection_data_get_surface (selection_data);
gtk_image_set_from_surface (GTK_IMAGE (data), surface);
cairo_surface_destroy (surface);
- break;
- case TARGET_TEXT:
+ }
+ else if (gtk_selection_data_targets_include_text (selection_data))
+ {
text = (gchar *)gtk_selection_data_get_text (selection_data);
gtk_image_set_from_icon_name (GTK_IMAGE (data), text);
g_free (text);
- break;
- default:
+ }
+ else
+ {
g_assert_not_reached ();
}
}
spinner_drag_data_get (GtkWidget *widget,
GdkDragContext *context,
GtkSelectionData *selection_data,
- guint info,
guint time,
gpointer data)
{
drag_data_get_cb (GtkWidget *widget,
GdkDragContext *context,
GtkSelectionData *data,
- guint info,
guint time,
gpointer user_data)
{
GTK_ENTRY_ICON_PRIMARY,
"Save a file");
tlist = gtk_target_list_new (NULL, 0);
- gtk_target_list_add_text_targets (tlist, 0);
+ gtk_target_list_add_text_targets (tlist);
gtk_entry_set_icon_drag_source (GTK_ENTRY (entry),
GTK_ENTRY_ICON_PRIMARY,
tlist, GDK_ACTION_COPY);
}
static const GtkTargetEntry item_targets[] = {
- { "GTK_TREE_MODEL_ROW", GTK_TARGET_SAME_APP, 0 }
+ { "GTK_TREE_MODEL_ROW", GTK_TARGET_SAME_APP }
};
gint
drag_data_get (GtkWidget *widget,
GdkDragContext *context,
GtkSelectionData *selection_data,
- guint info,
guint time,
gpointer data)
{
#include <gtk/gtk.h>
-enum
-{
- TARGET_GTK_TREE_MODEL_ROW
-};
-
static GtkTargetEntry row_targets[] =
{
- { "GTK_TREE_MODEL_ROW", GTK_TARGET_SAME_APP, TARGET_GTK_TREE_MODEL_ROW }
+ { "GTK_TREE_MODEL_ROW", GTK_TARGET_SAME_APP }
};
static void
#include <gtk/gtk.h>
static GtkTargetEntry entries[] = {
- { "GTK_LIST_BOX_ROW", GTK_TARGET_SAME_APP, 0 }
+ { "GTK_LIST_BOX_ROW", GTK_TARGET_SAME_APP }
};
static void
drag_data_get (GtkWidget *widget,
GdkDragContext *context,
GtkSelectionData *selection_data,
- guint info,
guint time,
gpointer data)
{
gint x,
gint y,
GtkSelectionData *selection_data,
- guint info,
guint32 time,
gpointer data)
{
};
static const GtkTargetEntry button_targets[] = {
- { "GTK_NOTEBOOK_TAB", GTK_TARGET_SAME_APP, 0 },
+ { "GTK_NOTEBOOK_TAB", GTK_TARGET_SAME_APP },
};
static GtkNotebook*
gint x,
gint y,
GtkSelectionData *data,
- guint info,
guint time,
gpointer user_data)
{
void
selection_get (GtkWidget *widget,
GtkSelectionData *selection_data,
- guint info,
guint time,
gpointer data)
{
guchar *buffer;
gint len;
- GdkAtom type = NULL;
if (!selection_string)
{
len = selection_string->len;
}
- switch (info)
- {
- case COMPOUND_TEXT:
- case TEXT:
- type = seltypes[COMPOUND_TEXT];
- break;
- case STRING:
- type = seltypes[STRING];
- break;
- }
-
- gtk_selection_data_set (selection_data, type, 8, buffer, len);
+ gtk_selection_data_set (selection_data,
+ gtk_selection_data_get_target (selection_data),
+ 8, buffer, len);
}
gint
GtkWidget *scrolled;
static GtkTargetEntry targetlist[] = {
- { "STRING", 0, STRING },
- { "TEXT", 0, TEXT },
- { "COMPOUND_TEXT", 0, COMPOUND_TEXT }
+ { "STRING", 0 },
+ { "TEXT", 0 },
+ { "COMPOUND_TEXT", 0 }
};
static gint ntargets = sizeof(targetlist) / sizeof(targetlist[0]);
GtkTargetList *list;
}
static GtkTargetEntry target_table[] = {
- { "application/x-toolbar-item", 0, 0 }
+ { "application/x-toolbar-item", 0 }
};
static void
}
static GtkTargetEntry row_targets[] = {
- { "GTK_TREE_MODEL_ROW", GTK_TARGET_SAME_APP, 0}
+ { "GTK_TREE_MODEL_ROW", GTK_TARGET_SAME_APP }
};
int
}
static GtkTargetEntry entries[] = {
- { "text/plain", 0, 0 }
+ { "text/plain", 0 }
};
static GtkWidget *
}
static void
-data_received (GtkWidget *widget,
- GdkDragContext *context,
- gint x, gint y,
- GtkSelectionData *selda,
- guint info, guint time,
- gpointer dada)
+drag_data_received (GtkWidget *widget,
+ GdkDragContext *context,
+ gint x, gint y,
+ GtkSelectionData *selda,
+ guint time,
+ gpointer dada)
{
gchar *text;
label = gtk_label_new ("Drop here");
targets = gtk_target_list_new (entries, G_N_ELEMENTS (entries));
gtk_drag_dest_set (label, GTK_DEST_DEFAULT_ALL, targets, GDK_ACTION_COPY);
- g_signal_connect (label, "drag-data-received", G_CALLBACK (data_received), NULL);
+ g_signal_connect (label, "drag-data-received", G_CALLBACK (drag_data_received), NULL);
gtk_target_list_unref (targets);
return label;
g_print ("Row activated\n");
}
-enum
-{
- TARGET_GTK_TREE_MODEL_ROW
-};
-
static GtkTargetEntry row_targets[] = {
- { "GTK_TREE_MODEL_ROW", GTK_TARGET_SAME_APP,
- TARGET_GTK_TREE_MODEL_ROW }
+ { "GTK_TREE_MODEL_ROW", GTK_TARGET_SAME_APP }
};
int
static void
test_with_data_get (GtkClipboard *clipboard,
GtkSelectionData *selection_data,
- guint info,
gpointer user_data_or_owner)
{
gboolean success;
- g_assert_cmpuint (info, ==, 42);
-
success = gtk_selection_data_set_text (selection_data, SOME_TEXT, -1);
g_assert (success);
}
test_with_data (void)
{
GtkClipboard *clipboard = gtk_clipboard_get_for_display (gdk_display_get_default (), GDK_SELECTION_CLIPBOARD);
- GtkTargetEntry entries[] = { { .target = TARGET_TEXT, .info = 42 } };
+ GtkTargetEntry entries[] = { { .target = TARGET_TEXT } };
GtkTargetList *targets;
targets = gtk_target_list_new (entries, G_N_ELEMENTS(entries));
projects / gtk4.git / commitdiff